\documentclass[a4paper,10pt]{report}\input{../0.Préambule/Préambule_cours_prof}\input{0_Préambule_Archi}\begin{document}

\newpage
\setcounter{chapter}{10}
\chapter{Protocole TCP}

\section{Qu'est-ce qu'un protocole ?}

\begin{dft}[Définition générale]
Ensemble des règles, questions, etc. , définissant une opération complexe : Protocole d'une expérience, d'un test. 
\end{dft}

\begin{dft}[Définition informatique]
Ensemble de règles définissant le mode de communication entre deux ordinateurs.
\end{dft}

\medskip
De manière générale, quand deux ordinateurs veulent communiquer entre-eux, il faut qu'ils respectent un ensemble de règles communes afin de bien se comprendre, c'est un protocole de communication. Sur un réseau local, on peut utiliser le protocole T.C.P. (Transmission Media Protocol en anglais) mais il en existe d'autres (UDP, …).

\begin{ex}
\begin{minipage}{11cm}
Je veux transmettre l'image ci-contre en binaire à mon voisin.

\textbf{Protocole choisi : }en commençant en haut à gauche et en parcourant cette image de gauche à droite ligne après ligne je code un pixel blanc par le chiffre $0$ et un pixel noir par le chiffre $1$.

On obtient donc la suite « 0010001010101010101000100 » que mon voisin pourra décoder s'il connaît le protocole.
\end{minipage}
\hspace{5mm}
\begin{minipage}{5cm}
\begin{center}
\renewcommand{\arraystretch}{1}
\begin{tabular}{|c|c|c|c|c|}
\hline
&&\cellcolor{black}{}&&\\\hline
&\cellcolor{black}{}&&\cellcolor{black}{}&\\\hline
\cellcolor{black}{}&&&&\cellcolor{black}{}\\\hline
&\cellcolor{black}{}&&\cellcolor{black}{}&\\\hline
&&\cellcolor{black}{}&&\\\hline
\end{tabular}
\end{center}
\end{minipage}
\end{ex}

\section{Vérification d'erreurs}

Quand on transmet des données sur un réseau le médium n'est pas parfait. Des erreurs peuvent donc survenir. Le protocole de transmission choisi doit donc être capable d'identifier les erreurs afin de pouvoir redemander une transmission si nécessaire (attention il n'est pas obligatoire que la méthode choisie permette de corriger elle-même l'erreur).

\medskip
Une méthode classique consiste à ajouter de manière régulière (en général tous les 7 bits) un bit supplémentaire pour qu’il y ait un nombre pair de 1 dans chaque section :

\begin{center}
\renewcommand{\arraystretch}{1.3}
\begin{tabular}{|c|c|c|c|c|c|c|c|}
\hline
\cellcolor{lightgray}{1}&1&0&1&0&0&0&1\\\hline
\end{tabular}
\end{center}
\hspace{5cm}bit de parité \quad\quad nombre impair de $1$.

\begin{ex}
Ajoutons un bit de parité tous les 5 bits (par ligne de l'image) dans l’exemple précédent. La suite à transmettre devient donc (bits de parité en gras) :
\begin{center}
« \textbf{1}00100 \textbf{0}01010 \textbf{1}10101 \textbf{0}01010 \textbf{1}00100 »
\end{center}
Si, à la réception, nous constatons qu'une section contient un nombre impair de $1$ c'est qu'il y a eu une erreur de transmission.
\end{ex}

\section{Découpage en paquets}

Supposons qu'un réseau local contienne $3$ ordinateurs $A$, $B$ et $C$. L'ordinateur $A$ souhaite envoyer $10$ Mo (soit environ $80 000 000$ de bits) à l'ordinateur $C$.
S'il envoie l'ensemble des données en une seule fois, plusieurs problèmes peuvent survenir :
\begin{enumerate}
\item[•] risque d'erreur : si un bit est corrompu, il faut ré-envoyer l'ensemble du fichier,
\item[•] médium non disponible : pendant ce temps l'ordinateur $B$ ne pourra ni envoyer ni recevoir de données.
\end{enumerate}

\medskip
Pour résoudre ces problèmes, on découpe les données à transmettre en paquets (par exemple de $1480$ octets chacun). On ajoute à chaque paquet de données un en-tête (de $20$ octets par exemple) pour contrôler la transmission. Ainsi le réseau est disponible pour plusieurs communications simultanées et, en cas d'erreur, seuls les paquets concernés doivent être ré-envoyés.

\medskip
Le but du protocole TCP est la gestion correcte de tous ces paquets sur un réseau local :
\begin{enumerate}
\item[•] s'assurer qu'un paquet émis est bien reçu,
\item[•] vérifier que le paquet ne contient pas d'erreurs,
\item[•] vérifier que tous les paquets sont bien dans le bon ordre à la fin.
\end{enumerate}

\medskip
\textbf{Point histoire : }Le protocole TCP a été inventé par Bob Kahn et Vinton Cerf en 1973. Il sera adopté en mars 1982 par les militaires sur le réseau ARPANET. Il reste le protocole le plus utilisé de nos jours !

\section{Protocole du bit alterné}

Ce protocole a pour objectif de s'assurer que tous les paquets émis arrivent en bon état à destination. Dans l'en-tête du paquet, un bit est réservé pour indiquer la parité du paquet (par exemple le paquet numéro $1$ portera le bit $1$). Quand le destinataire reçoit le paquet, il renvoie lui-même un message (appelé acquittement et noté ACK) en inversant (alternant) le bit de parité pour indiquer qu'il est prêt pour le paquet suivant. Si, au bout d'un certain temps, l'émetteur n'a pas reçu le message avec le bit alterné, il considère que le message s'est perdu, ou qu'il contenait une erreur, et il le renvoie de nouveau. Et ainsi de suite ...

\begin{rmq}
En pratique le protocole TCP utilise des nombres codés sur $32$ bits pour tracer les paquets.
\end{rmq}

\end{document}